25 research outputs found
Fault-tolerant Distributed Reactive Programming
In this paper, we present a holistic approach to provide fault tolerance for distributed reactive programming. Our solution automatically stores and recovers program state to handle crashes, automatically updates and shares distributed parts of the state to provide eventual consistency, and handles errors in a fine-grained manner to allow precise manual control when necessary. By making use of the reactive programming paradigm, we provide these mechanisms without changing the behavior of existing programs and with reasonable performance, as indicated by our experimental evaluation
LoRe: A Programming Model for Verifiably Safe Local-First Software
Local-first software manages and processes private data locally while still
enabling collaboration between multiple parties connected via partially
unreliable networks. Such software typically involves interactions with users
and the execution environment (the outside world). The unpredictability of such
interactions paired with their decentralized nature make reasoning about the
correctness of local-first software a challenging endeavor. Yet, existing
solutions to develop local-first software do not provide support for automated
safety guarantees and instead expect developers to reason about concurrent
interactions in an environment with unreliable network conditions.
We propose LoRe, a programming model and compiler that automatically verifies
developer-supplied safety properties for local-first applications. LoRe
combines the declarative data flow of reactive programming with static analysis
and verification techniques to precisely determine concurrent interactions that
violate safety invariants and to selectively employ strong consistency through
coordination where required. We propose a formalized proof principle and
demonstrate how to automate the process in a prototype implementation that
outputs verified executable code. Our evaluation shows that LoRe simplifies the
development of safe local-first software when compared to state-of-the-art
approaches and that verification times are acceptable.Comment: This is the extended version of the work accepted at ECOOP 202
LoRe: A Programming Model for Verifiably Safe Local-First Software (Artifact)
Local-first software manages and processes private data locally while still enabling collaboration between multiple parties connected via partially unreliable networks. Such software typically involves interactions with users and the execution environment (the outside world). The unpredictability of such interactions paired with their decentralized nature make reasoning about the correctness of local-first software a challenging endeavor. Yet, existing solutions to develop local-first software do not provide support for automated safety guarantees and instead expect developers to reason about concurrent interactions in an environment with unreliable network conditions.
We propose LoRe, a programming model and compiler that automatically verifies developer-supplied safety properties for local-first applications. LoRe combines the declarative data flow of reactive programming with static analysis and verification techniques to precisely determine concurrent interactions that violate safety invariants and to selectively employ strong consistency through coordination where required. We propose a formalized proof principle and demonstrate how to automate the process in a prototype implementation that outputs verified executable code. Our evaluation shows that LoRe simplifies the development of safe local-first software when compared to state-of-the-art approaches and that verification times are acceptable
LoRe: A Programming Model for Verifiably Safe Local-First Software (Extended Abstract)
Local-first software manages and processes private data locally while still enabling collaboration between multiple parties connected via partially unreliable networks. Such software typically involves interactions with users and the execution environment (the outside world). The unpredictability of such interactions paired with their decentralized nature make reasoning about the correctness of local-first software a challenging endeavor. Yet, existing solutions to develop local-first software do not provide support for automated safety guarantees and instead expect developers to reason about concurrent interactions in an environment with unreliable network conditions.
We propose LoRe, a programming model and compiler that automatically verifies developer-supplied safety properties for local-first applications. LoRe combines the declarative data flow of reactive programming with static analysis and verification techniques to precisely determine concurrent interactions that violate safety invariants and to selectively employ strong consistency through coordination where required. We propose a formalized proof principle and demonstrate how to automate the process in a prototype implementation that outputs verified executable code. Our evaluation shows that LoRe simplifies the development of safe local-first software when compared to state-of-the-art approaches and that verification times are acceptable
A Fault-Tolerant Programming Model for Distributed Interactive Applications
Ubiquitous connectivity of web, mobile, and IoT computing platforms has fostered a variety of distributed applications with decentralized state. These applications execute across multiple devices with varying reliability and connectivity. Unfortunately, there is no declarative fault-tolerant programming model for distributed interactive applications with an inherently decentralized system model. We present a novel approach to automating fault tolerance using high-level programming abstractions tailored to the needs of distributed interactive applications. Specifically, we propose a calculus that enables formal reasoning about applications' dataflow within and across individual devices. Our calculus reinterprets the functional reactive programming model to seamlessly integrate its automated state change propagation with automated crash recovery of device-local dataflow and disconnection-tolerant distribution with guaranteed automated eventual consistency semantics based on conflict-free replicated datatypes. As a result, programmers are relieved of handling intricate details of distributing change propagation and coping with distribution failures in the presence of interactivity. We also provides proofs of our claims, an implementation of our calculus, and an empirical evaluation using a common interactive application
Smart Street Lights and Mobile Citizen Apps for Resilient Communication in a Digital City
Currently, nearly four billion people live in urban areas. Since this trend
is increasing, natural disasters or terrorist attacks in such areas affect an
increasing number of people. While information and communication technology is
crucial for the operation of urban infrastructures and the well-being of its
inhabitants, current technology is quite vulnerable to disruptions of various
kinds. In future smart cities, a more resilient urban infrastructure is
imperative to handle the increasing number of hazardous situations. We present
a novel resilient communication approach based on smart street lights as part
of the public infrastructure. It supports people in their everyday life and
adapts its functionality to the challenges of emergency situations. Our
approach relies on various environmental sensors and in-situ processing for
automatic situation assessment, and a range of communication mechanisms (e.g.,
public WiFi hotspot functionality and mesh networking) for maintaining a
communication network. Furthermore, resilience is not only achieved based on
infrastructure deployed by a digital city's municipality, but also based on
integrating citizens through software that runs on their mobile devices (e.g.,
smartphones and tablets). Web-based zero-installation and platform-agnostic
apps can switch to device-to-device communication to continue benefiting people
even during a disaster situation. Our approach, featuring a covert channel for
professional responders and the zero-installation app, is evaluated through a
prototype implementation based on a commercially available street light.Comment: 2019 IEEE Global Humanitarian Technology Conference (GHTC
ReactiFi: Reactive Programming of Wi-Fi Firmware on Mobile Devices
Network programmability will be required to handle future increased network
traffic and constantly changing application needs. However, there is currently
no way of using a high-level, easy to use programming language to program Wi-Fi
firmware. This impedes rapid prototyping and deployment of novel network
services/applications and hinders continuous performance optimization in Wi-Fi
networks, since expert knowledge is required for both the used hardware
platforms and the Wi-Fi domain. In this paper, we present ReactiFi, a
high-level reactive programming language to program Wi-Fi chips on mobile
consumer devices. ReactiFi enables programmers to implement extensions of PHY,
MAC, and IP layer mechanisms without requiring expert knowledge of Wi-Fi chips,
allowing for novel applications and network protocols. ReactiFi programs are
executed directly on the Wi-Fi chip, improving performance and power
consumption compared to execution on the main CPU. ReactiFi is conceptually
similar to functional reactive languages, but is dedicated to the
domain-specific needs of Wi-Fi firmware. First, it handles low-level
platform-specific details without interfering with the core functionality of
Wi-Fi chips. Second, it supports static reasoning about memory usage of
applications, which is important for typically memory-constrained Wi-Fi chips.
Third, it limits dynamic changes of dependencies between computations to
dynamic branching, in order to enable static reasoning about the order of
computations. We evaluate ReactiFi empirically in two real-world case studies.
Our results show that throughput, latency, and power consumption are
significantly improved when executing applications on the Wi-Fi chip rather
than in the operating system kernel or in user space. Moreover, we show that
the high-level programming abstractions of ReactiFi have no performance
overhead compared to manually written C code